Systematic formulation of non-functional characteristics of software

This paper presents NoFun, a notation aimed at dealing with non-functional aspects of software systems at the product level in the component programming framework. NoFun can be used to define hierarchies of non-functional attributes, which can be bound to individual software components, libraries of components or (sets of) software systems. Non-functional attributes can be defined in several ways, being possible to choose a particular definition in a concrete context. Also, NoFun allows to state the values of the attributes in component implementations, and to formulate non-functional requirements over component implementations. The notation is complemented with an algorithm able to select the best implementation of components (with respect to their non-functional characteristics) in their context of use.Peer ReviewedPostprint (published version

A goal model for crowdsourced software engineering

Crowdsourced Software Engineering (CSE) is the act of undertaking any external software engineering tasks by an undefined, potentially large group of online workers in an open call format. Using an open call, CSE recruits global online labor to work on various types of software engineering tasks, such as requirements extraction, design, coding and testing. The field is rising rapidly and touches various aspects of software engineering. CSE has grown significance in both academy and industry. Despite of the enormous usage and significance of CSE, there are many open challenges reported by various researchers. In order to overcome the challenges and realizing the full potential of CSE, it is highly important to understand the concrete advantages and goals of CSE. In this paper, we present a goal model for CSE, to understand the real environment of CSE, and to explore the aspects that can somehow overcome the aforementioned challenges. The model is designed using RiSD, a method for building Strategic Dependency (SD) models in the i* notation, applied in this work using iStar2.0. This work can be considered useful for CSE stakeholders (Requesters, Workers, Platform owners and CSE organizations).Peer ReviewedPostprint (published version

Using contextual goal models for constructing situational methods

Situation and intention are two fundamental notions in situational method engineering (SME). They are used to assess the context of an ISD project and to specify method requirements in this context. They also allow defining the goals of the method chunks and the conditions under which they can be applied. In this way, the selection and assembly of method chunks for a particular ISD project is driven by matching situational method requirements to method chunks’ goals and context descriptions. In this paper we propose the use of contextual goal models for supporting all SME steps. Our approach is based on iStar2.0 modeling language that we extend with contextual annotations.Peer ReviewedPostprint (author's final draft

StarGro: Building i* metrics for agile methodologies

Requirements management is one of the cornerstone activities in software development. Agile methodologies use dedicated methods, techniques and artifacts in order to implement this activity. Remarkably, Backlog Grooming is the activity of managing and welcoming changing requirements in SCRUM. However, current industrial practices in agile development still tend to render this process in the shape of a list of statements, features and bug fixes that often leads to a blurred view of the goals of the project, the underestimation of client's needs and the decrease of the ability to respond to changes. In this paper we outline an approach that uses goal and agent oriented modelling techniques in order to fill in this "intentional" gap that current industrial approaches lack.Peer ReviewedPostprint (published version

Supporting software maintenance with non-functional information

The paper highlights the role of non functional information (about efficiency, reliability and other software attributes) of software components in software maintenance, focusing in the component programming framework. Non functional information is encapsulated in modules bound to both definitions and implementations of software components and it is written as expressions in a classical programming language. It is shown with an example how this notation supports software maintenance, with the help of an algorithm which is able to select the best implementation of a software component in its context of use, meaning byPeer ReviewedPostprint (published version

Improving design and implementation of OO container-like component libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles tend to be just partially applied to the subsequent object-oriented implementation, often because they conflict with other quality criteria (remarkably, efficiency). So, there is a gap between design and implementation: due to these conflicts developers use to give up design level abstractions during the implementation. In this paper we present a framework for bridging this gap for a concrete domain, the design and implementation of object-oriented container-like component libraries, such as JCF, STL, Booch Components, LEDA, etc. At the core of the framework we propose a new design pattern called emph{Shortcut} together with its corresponding implementation. The Shortcut pattern, introduced in a generic base class container, provides a secure and efficient access to items in a container decoupled from the implementation details of concrete containers. Shortcut enhances applying the same principles that drive the design process to the implementation process of these libraries: step-by-step implementation, implementation with reuse and implementation for reuse without penalising other quality criteria. Our framework not only supports the design and implementation of new libraries but also the reengineering of existing ones to overcome some of their drawbacks. We show by a case study, reengineering the Booch Components in Ada95, the application and benefits of our framework.Postprint (published version

Bridging the gap between design and implementation of components libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles are just partially applied to the subsequent object-oriented implementation, often due to efficienc y constraints, yielding to a gap between design and implementation. In this paper we provide a solution for bridging this gap for a concrete framework, the one of designing and implementing container-like component libraries, such as STL, Booc h Components, etc. Our approach is based on a new design pattern together with its corresponding implementation. The proposal enhances the same principles that drive the design process: step-by--step implementation (adding just what is needed in every step), implementation with reuse (component implementations are reused while library implementation progresses and component hierarchies grow) and implementation for reuse (intermediate component implementations can be reused in many different points o f the hierarchy). We use our approach in two different manners: for building a brand-new container-like component library, and for reengineering an existing one, Booch Components in Ada95.Postprint (published version

A metrics definition framework for i*

Measuring is a central task in the any engineering discipline, and modelling is not an exception. The need for measuring properties over i* models arises in different contexts. We have analysed this need over i* models of organizations, projects, systems and architectures. As a result, we have proposed a framework which includes: (a) a metamodel of i* that defines the elements that build the model; (b) a framework for the definition of metrics; (c) a collection of metrics (currently under construction) of different nature built with the framework. In this work, we present these basic concepts and discuss the applicability of the approach.Peer ReviewedPostprint (published version

Adding efficient and reliable access paths to the JCF

The Java Collections Framework (JCF) is the standard Java library for representing and manipulating collections (i.e., objects that represent a group of objects, such as sets, lists, etc.). Although JCF provides adequate functionality for many purposes, it does not offer any mechanism for accessing directly the objects stored in collections apart from the standard Java references. This absence is a crucial functionality exhibited by many other widespread Java and non-Java collection libraries. In this paper, we carry out a reengineering process on the JCF to add this kind of alternative access paths, which we give the name of shortcuts. This process relies on a framework called Shortcut-Based Framework, which has been defined as library- independent. We present this framework and then we show how it may be tailored to the specific case of the JCF. The resulting JCF with shortcuts library is fully compatible with the original one (i.e., programs using the original JCF are not required to be modified), and exhibits good behaviour with respect to efficiency, reliability and internal quality. As an additional benefit of the framework, we mention that it can be applied to other collection libraries, as we have done before with an Ada95 one.Postprint (published version

Including non-functional issues in Anna/Ada programs for automatic implementation selection

We present an enrichment of the Anna specification language for Ada aimed at dealing not only with functional specification of packages but also with non-functional information about them. By non-functional information we mean information about efficiency, reliability and, in general, any software attribute measuring somehow the quality of software (perhaps in a subjective manner). We divide this information into three kinds: definition of non-functional properties, statement of non-functional behaviour and statement of non-functional requirements; like Anna annotations, all of this information appears in Ada packages and package bodies and their syntax is close to Ada constructs. Non-functional information may be considered not only as valuable comments, but also as an input for an algorithm capable of selecting the “best” package body for every package definition in a program, the “best” meaning the one that fits the set of non-functional requirements of the package in the program.Peer ReviewedPostprint (author's final draft